package main

import (
	"context"
	"fmt"
	"time"

	"github.com/hyahm/golog"
)

// go get github.com/hyahm/golog

// func getting(w http.ResponseWriter, r *http.Request) {
// 	golog.Info(r.URL.Path)
// 	golog.Info("getting")
// 	w.Write([]byte("xmux test method"))
// }

// func get(w http.ResponseWriter, r *http.Request) {
// 	golog.Info(r.URL.Path)
// 	golog.Info("get")
// 	w.Write([]byte("xmux test method"))
// }

// func M1(w http.ResponseWriter, r *http.Request) bool {
// 	golog.Error("m1")
// 	w.Write([]byte("xmux test method"))
// 	return false
// }

// func M2(w http.ResponseWriter, r *http.Request) bool {
// 	golog.Info("m2")
// 	w.Write([]byte("xmux test method"))
// 	return false
// }

// func DefaultMidwareTemplate(handle func(http.ResponseWriter, *http.Request), w http.ResponseWriter, r *http.Request) {
// 	start := time.Now()
// 	// todo yon
// 	fmt.Println("DefaultMidwareTemplate")
// 	handle(w, r)
// 	// r.PostFormValue()
// 	fmt.Printf("url: %s -- addr: %s -- method: %s -- exectime: %f\n", r.URL.Path, r.RemoteAddr, r.Method, time.Since(start).Seconds())
// }

// type Login struct {
// 	User     string `json:"user" xml:"user"`
// 	Password string `json:"password" xml:"password"`
// }

// func bind(w http.ResponseWriter, r *http.Request) {
// 	login := xmux.GetInstance(r).Data.(*Login)
// 	golog.Infof("%#v", *login)
// }

// func parseJson(w http.ResponseWriter, r *http.Request) bool {
// 	b, err := io.ReadAll(r.Body)
// 	if err != nil {
// 		w.Write([]byte(err.Error()))
// 		return true
// 	}
// 	golog.Info(string(b))
// 	err = json.Unmarshal(b, xmux.GetInstance(r).Data)
// 	if err != nil {
// 		w.Write([]byte(err.Error()))
// 		return true
// 	}
// 	return false
// }

// func parseForm(w http.ResponseWriter, r *http.Request) bool {
// 	login := &Login{
// 		User:     r.FormValue("user"),
// 		Password: r.FormValue("password"),
// 	}
// 	xmux.GetInstance(r).Data = login
// 	return false
// }

// func enter(w http.ResponseWriter, r *http.Request) bool {
// 	// golog.Info(r.Host)
// 	// golog.Info(r.RequestURI)
// 	// http://localhost:2222/
// 	// r.RemoteAddr
// 	golog.Info(r.URL.Path, "-----", r.Method)
// 	golog.Info(time.Now().Nanosecond())
// 	// first := time.Now()
// 	// second := time.Now()
// 	return false
// }

// func exit(start time.Time, w http.ResponseWriter, r *http.Request) {
// 	// golog.Info(r.Host)
// 	// golog.Info(r.RequestURI)
// 	// http://localhost:2222/
// 	// r.RemoteAddr
// 	time.Sleep(1 * time.Second)
// 	golog.Info(start.Nanosecond())
// }

// func bindxml(w http.ResponseWriter, r *http.Request) {
// 	login := xmux.GetInstance(r).Data.(*Login)
// 	golog.Infof("%#v", *login)
// }

// func handleNotFound() http.Handler {
// 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// 		w.Header().Add("Access-Control-Allow-Origin", "*")
// 		w.Write([]byte("404 page not found"))
// 	})
// }

// func PlayVideo(w http.ResponseWriter, r *http.Request) {
// 	filename := xmux.Var(r)["filename"]
// 	f, err := os.Open(filepath.Join("D:\\Videos", filename))
// 	if err != nil {
// 		golog.Error(err)
// 		w.WriteHeader(404)
// 		return
// 	}
// 	defer f.Close()
// 	http.ServeContent(w, r, filename, time.Now(), f)
// }

func GoContext(ctx context.Context) {
	value := ctx.Value("aaa")
	fmt.Println(value)
	for {
		select {
		// case <-"";
		// todo
		case <-ctx.Done():

			fmt.Println(time.Now())
			fmt.Println("stoped")
			return
		}
	}

}

// func slash(w http.ResponseWriter, r *http.Request) {
// 	//   /
// 	go func() {
// 		fmt.Println()
// 	}()
// 	w.Write([]byte("ok"))
// }

func main() {
	// time.Sleep(1 * time.Second)

	// ctx, cancel := context.WithCancel(context.Background())
	// fmt.Println(time.Now())
	ctx, _ := context.WithDeadline(context.Background(), time.Now().Add(5*time.Second))
	// ctx2, cancel2 := context.WithTimeout(context.Background(), 10*time.Second)

	ctx = context.WithValue(ctx, "aaa", "bbb")
	// go slash(nil, nil)
	// 更简单， 速度更快， 更安全
	defer golog.Sync()

	go GoContext(ctx)
	////
	time.Sleep(5 * time.Second)
	// cancel() // 发送停止信号
	// 明天将  context，  python： 装饰器
	// goconfig.InitConf("learn.ini", goconfig.INI)
	// db.ConnectMysql()

	for {
	}
	// internal.RunInterface()
	// router := xmux.NewRouter()
	// 设置中心
	// router.AddGroup(pages.Setting)
	// v2 := xmux.NewGroupRoute()
	// v2.Get("/get", slash)
	// // router.Slash = true
	// router.AddGroup(v2)
	// router.Get("/get", slash)
	// router.DebugAssignRoute("/env/read") // 打印所有非正则匹配的路由信息
	// router.DebugRoute()                  // // 打印所有非正则路由信息
	// router.DebugTpl()                    // 打印所有正则路由信息
	// router.DebugIncludeTpl("/aaa")       // 打印所有正则匹配的路由信息
	// router.Run(goconfig.ReadString("listen", ":80"))
	// golog.InitLogger("log/xmux.log", 0, true, 7*time.Hour*24)
	// golog.Info("start")

	// // 处理函数之前一般用的最多的是权限处理 module
	// router := xmux.NewRouter()
	// // router.Get("/ping", func(w http.ResponseWriter, r *http.Request) {
	// // 	w.Write([]byte(`{"message":"pong"}`))
	// // })
	// // 中间件
	// // r.GET("/benchmark", MyBenchLogger1, func(c *gin.Context) {
	// // 	panic("benchmark")
	// // })
	// v1 := xmux.NewGroupRoute().MiddleWare(DefaultMidwareTemplate).AddModule(M1)
	// v1.Get("/v1/login", bind).Bind(Login{}).AddModule(parseJson)
	// v1.Post("/v1/login", bind).BindJson(Login{})
	// v1.Get("/v1/submit", getting)
	// v1.Get("/v1/read", getting).DelModule(M1).MiddleWare(DefaultMidwareTemplate)

	// v2 := xmux.NewGroupRoute()
	// v2.Get("/v2/login", bind).BindXml(Login{})
	// v2.Get("/v2/submit", bind).AddModule(parseForm)
	// v2.Get("/v2/read", getting).AddModule(M2)

	// v1.AddGroup(v2)

	// router.AddGroup(v1)
	// 上传文件
	// router.Post("/upload", func(w http.ResponseWriter, r *http.Request) {
	// 	// single file
	// 	r.ParseMultipartForm(8 << 20) //router.MaxMultipartMemory = 8 << 20 // 8 MiB
	// 	b, header, _ := r.FormFile("file")
	// 	// file, _ := c.FormFile("file")
	// 	// log.Println(file.Filename)
	// 	f, _ := os.OpenFile("xmux_file", os.O_CREATE|os.O_WRONLY, 0644)
	// 	// Upload the file to specific dst.
	// 	io.Copy(f, b)
	// 	// c.SaveUploadedFile(file, "upload_file")

	// 	w.Write([]byte(fmt.Sprintf("'%s' uploaded!", header.Filename)))
	// })
	// router.Post("/form_post", func(w http.ResponseWriter, r *http.Request) {
	// 	message := r.PostFormValue("message")
	// 	nick := r.PostFormValue("nick")

	// 	msg := fmt.Sprintf(`{
	// 		"status":  "posted",
	// 		"message": %s,
	// 		"nick":    %s,
	// 	}`, message, nick)
	// 	w.Write([]byte(msg))
	// })
	// router.Get("/welcome", func(w http.ResponseWriter, r *http.Request) {
	// 	firstname := r.URL.Query().Get("firstname")
	// 	if firstname == "" {
	// 		firstname = "Guest"
	// 	}
	// 	lastname := r.URL.Query().Get("lastname") // shortcut for c.Request.URL.Query().Get("lastname")

	// 	msg := fmt.Sprintf("Hello %s %s", firstname, lastname)
	// 	w.Write([]byte(msg))
	// })
	// router.Get("/someGet", getting)
	// router.Post("/somePost", getting)
	// router.Put("/somePut", getting)
	// router.Delete("/someDelete", getting)
	// router.Patch("/somePatch", getting)
	// router.Head("/someHead", getting)
	// router.OPTIONS("/someOptions", getting)

	// // This handler will match /user/john but will not match /user/ or /user
	// word   .+
	// router.Get("/user/{re:([0-9]{1,10})([a-z]{1,4}):age,name}", func(w http.ResponseWriter, r *http.Request) {
	// 	age := xmux.Var(r)["age"]
	// 	name := xmux.Var(r)["name"]
	// 	resp := "Hello " + name + " age: " + age
	// 	w.Write([]byte(resp))
	// })

	// router.Get("/user/{re:([0-9]{1,10})-([a-z]{1,10}):age,name}", func(w http.ResponseWriter, r *http.Request) {
	// 	age := xmux.Var(r)["age"]
	// 	name := xmux.Var(r)["name"]
	// 	resp := "Hello " + name + " age: " + age
	// 	w.Write([]byte(resp))
	// })

	// // However, this one will match /user/john/ and also /user/john/send
	// // If no other routers match /user/john, it will redirect to /user/john/
	// router.GET("/user/:name/*action", func(c *gin.Context) {
	// 	name := c.Param("name")
	// 	action := c.Param("action")
	// 	message := name + " is " + action
	// 	c.String(http.StatusOK, message)
	// })

	// For each matched request Context will hold the route definition
	// router.POST("/user/:name/*action", func(c *gin.Context) {
	// 	fmt.Println(c.FullPath())
	// 	b := c.FullPath() == "/user/:name/*action" // true
	// 	c.String(http.StatusOK, "%t", b)
	// })

	// // This handler will add a new router for /user/groups.
	// // Exact routes are resolved before param routes, regardless of the order they were defined.
	// // Routes starting with /user/groups are never interpreted as /user/:name/... routes
	// router.GET("/user/groups", func(c *gin.Context) {
	// 	c.String(http.StatusOK, "The available groups are [...]")
	// })
	// router := xmux.NewRouter()
	// router.HandleNotFound = handleNotFound()
	// router.Get("/", getting).ApiCreateGroup("test", "test", "test").ApiDescribe("mioahsldjflsadjf")
	// // 允许所有请求， 但是不包含options
	// // router.HandleOptions 如果要单独处理options 请求就写自定义的handle
	// router.AddGroup(router.ShowApi("/doc"))
	// // xmux.NewDocs(router)
	// // router.AddGroup()
	// router.Request("/{request}", getting, http.MethodGet, http.MethodPost)
	// router.Any("/any", get)
	// router.IgnoreIco = true
	// router.HanleFavicon
	// 请求进入的时候就会调用， 一般是做调试过滤用的
	// router.Enter = enter
	// // 可以统计xmux路由整体处理的时间， 不包含网络请求时间和go http内置解析的时间
	// router.Exit = exit
	// // 允许跨域的域名  * 表示允许所有
	// router.SetHeader("Access-Control-Allow-Origin", "*")
	// //服务器支持的所有请求的方法
	// // router.SetHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE,UPDATE")
	// // 允许设置可以返回其他请求头
	// router.SetHeader("Access-Control-Allow-Headers", "Authorization, Content-Length, X-CSRF-Token, Token, session")
	// 允许浏览器（客户端）可以解析的头部 （重要）
	// router.SetHeader("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers")
	//设置缓存时间
	// router.SetHeader("Access-Control-Max-Age", "172800")
	//允许客户端传递校验信息比如 cookie (重要)
	// router.SetHeader("Access-Control-Allow-Credentials", "true")
	// router.Get("/", func(rw http.ResponseWriter, r *http.Request) {
	// 	rw.Write([]byte("ok"))
	// })
	// router.Get("/log/{string:filename}", func(rw http.ResponseWriter, r *http.Request) {
	// 	fn := xmux.Var(r)["filename"]

	// 初级的读取文件，不建议使用
	// b, err := os.ReadFile(filepath.Join("log", fn))
	// if err != nil {
	// 	rw.WriteHeader(404)
	// 	return
	// }
	// rw.Write(b)
	// 推荐方法
	// f, err := os.Open(filepath.Join("log", fn))
	// if err != nil {
	// 	rw.WriteHeader(404)
	// 	return
	// }

	// defer f.Close()
	// io.Copy(rw, f)
	// 读大文件的写法, 比如视频文件
	// f, err := os.Open(filepath.Join("log", fn))
	// if err != nil {
	// 	rw.WriteHeader(404)
	// 	return
	// }
	// rw.Header().Set("Content-Type", "video/mp4")
	// defer f.Close()
	// http.ServeContent(rw, r, fn, time.Now(), f)
	// })
	// router.Run(":2222")
}
